home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gs_cmap.ps < prev    next >
Encoding:
Text File  |  1997-06-11  |  7.5 KB  |  243 lines
  1. %    Copyright (C) 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of Aladdin Ghostscript.
  4. % 
  5. % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. % or distributor accepts any responsibility for the consequences of using it,
  7. % or for whether it serves any particular purpose or works at all, unless he
  8. % or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. % License (the "License") for full details.
  10. % 
  11. % Every copy of Aladdin Ghostscript must include a copy of the License,
  12. % normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. % the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. % under certain conditions described in the License.  Among other things, the
  15. % License requires that the copyright notice and this notice be preserved on
  16. % all copies.
  17.  
  18. % ProcSet for implementing CMap resources.
  19. % When this is run, systemdict is still writable.
  20.  
  21. % NOTE: Rearranged fonts are not implemented yet.
  22.  
  23. % ---------------- Public operators ---------------- %
  24.  
  25. % composefont doesn't appear in CMap files -- it's documented in
  26. % the "PostScript Language Reference Manual Supplement".
  27. /composefont        % <name> <cmap|cmapname> <fonts> composefont <font>
  28.  { 10 dict begin
  29.      1 index dup type /dicttype ne { /CMap findresource } if
  30.         /CMap exch def
  31.      /Encoding [ 0 1 4 index length 1 sub { } for ] def
  32.      /FDepVector 1 index def
  33.      /FMapType 9 def
  34.      /FontMatrix matrix def
  35.      /FontName 3 index def
  36.      /CMap load /WMode .knownget { /WMode exch def } if
  37.      /FontType 0 def
  38.    pop pop currentdict end /Font defineresource
  39.  } bind odef
  40.  
  41. % ---------------- CMap operators ---------------- %
  42.  
  43. 30 dict begin
  44.  
  45. % Our internal .CodeMaps structure is an array of two arrays: array 0
  46. % is the map for defined characters, array 1 is the map for notdefs.
  47. % Both are multi-level arrays indexed by the successive bytes of the
  48. % character code.  Each value is either a sub-array, null, a character name,
  49. % a CID (an integer), or a character code (expressed as a byte string).
  50. % All of the arrays are read-only after they have been built.
  51. %
  52. % Note that the code in zfcmap.c that constructs the C structures from
  53. % the PostScript structures has intimate knowledge of the above format.
  54.  
  55. /.getmap { .CodeMaps exch get } bind def
  56. /.putmap { .CodeMaps exch 3 -1 roll put } bind def
  57.  
  58. % ------ Font-level operators ------ %
  59.  
  60. /begincmap        % - begincmap -
  61.  { /.CodeMaps [256 array 256 array] def
  62.  } bind def
  63. /endcmap        % - endcmap -
  64.  { /.CodeMaps .CodeMaps .endmap def
  65.    /CodeMap null def        % for .buildcmap
  66.    currentdict end .buildcmap begin
  67.  } bind def
  68.  
  69. /begincodespacerange    % <count> begincodespacerange -
  70.  { pop mark
  71.  } bind def
  72. /endcodespacerange    % <code_lo> <code_hi> ... endcodespacerange -
  73.  { counttomark 2 idiv
  74.     { .CodeMaps { 3 copy .addcodespacerange pop } forall pop pop
  75.     } repeat pop
  76.  } bind def
  77.  
  78. /.addcodespacerange    % <code_lo> <code_hi> <map> .addcodespacerange -
  79.  { 2 index length 1 eq
  80.     { 2 { 3 -1 roll 0 get } repeat 1 exch
  81.        { 2 copy 0 put pop } for pop
  82.     }
  83.     { 2 index 0 get 1 3 index 0 get
  84.       6 -2 roll
  85.       2 { 1 1 index length 1 sub getinterval 6 1 roll } repeat
  86.         % Stack: lo hi map lo0 1 hi0
  87.        { 2 copy get null eq { 2 copy 256 array put } if
  88.          4 copy get .addcodespacerange pop
  89.        }
  90.       for pop pop pop
  91.     }
  92.    ifelse
  93.  } bind def
  94. /.endmap        % <map> .endmap <map>
  95.  { dup type /arraytype eq { dup { .endmap exch } forall astore readonly } if
  96.  } bind def
  97.  
  98. /usecmap        % <CMap_name> usecmap -
  99.  { /CMap findresource
  100.    dup length dict .copydict
  101.    currentdict end exch .copydict begin
  102.  } bind def
  103.  
  104. % ------ Rearranged font operators ------ %
  105.  
  106. /beginrearrangedfont    % <font_name> <font*> beginrearrangedfont -
  107.  {    (NOT IMPLEMENTED YET.\n) print flush
  108.  } bind def
  109. /endrearrangedfont    % - endrearrangedfont -
  110.  {    (NOT IMPLEMENTED YET.\n) print flush
  111.  } bind def
  112.  
  113. /usefont        % <fontID> usefont -
  114.  {    (NOT IMPLEMENTED YET.\n) print flush
  115.  } bind def
  116.  
  117. /beginusematrix        % <fontID> beginusematrix -
  118.  {    (NOT IMPLEMENTED YET.\n) print flush
  119.  } bind def
  120. /endusematrix        % <matrix> endusematrix -
  121.  {    (NOT IMPLEMENTED YET.\n) print flush
  122.  } bind def
  123.  
  124. % ------ Character name/code selector operators ------ %
  125.  
  126. /beginbfchar        % <count> beginbfchar -
  127.  { pop mark
  128.  } bind def
  129. /endbfchar        % <code> <to_code|charname> ... endbfchar
  130.  { 0 .getmap .endmapchar 0 .putmap
  131.  } bind def
  132.  
  133. /beginbfrange        % <count> beginbfrange -
  134.  { pop mark
  135.  } bind def
  136. /endbfrange        % <code_lo> <code_hi> <to_code|(charname*)> ...
  137.             %   endbfrange -
  138.  { 0 .getmap counttomark 3 idiv { .addbfrange } repeat 0 .putmap pop
  139.  } bind def
  140.  
  141. /.addbfrange        % <code_lo> <code_hi> <to_code|(charname*)> <map>
  142.             %   .addbfrange <map>
  143.  { 1 index type /stringtype eq
  144.     {  { dup length string copy dup dup length 1 sub 2 copy get 1 add put }
  145.       exch .addmaprange
  146.     }
  147.     { 2 dict begin exch /codes 1 index def 0 get exch
  148.        { codes dup length 1 sub 1 exch getinterval /codes 1 index def
  149.      dup length 0 gt { 0 get } if
  150.        }
  151.       exch .addmaprange end
  152.     }
  153.    ifelse exch pop
  154.  } bind def
  155.  
  156. % ------ CID selector operators ------ %
  157.  
  158. /begincidchar        % <count> begincidchar -
  159.  { pop mark
  160.  } bind def
  161. /endcidchar        % <code> <cid> ... endcidchar -
  162.  { 0 .getmap .endmapchar 0 .putmap
  163.  } bind def
  164.  
  165. /begincidrange        % <count> begincidrange -
  166.  { pop mark
  167.  } bind def
  168. /endcidrange        % <code_lo> <code_hi> <cid_base> ... endcidrange -
  169.  { 0 .getmap counttomark 3 idiv { { 1 add } exch .addmaprange exch pop } repeat
  170.    0 .putmap pop
  171.  } bind def
  172.  
  173. /.endmapchar        % -mark- <code> <value> ... <map> .endmapchar -
  174.  { counttomark 2 idiv
  175.     { 2 index 3 1 roll { } exch .addmaprange exch pop
  176.     } repeat exch pop
  177.  } bind def
  178.  
  179. /.addmaprange        % <code_lo> <code_hi> <value_base> <next_proc> <map>
  180.             %   .addcidrange <value_next> <map>
  181.  {    % We may be updating a (partly) read-only map from another CMap.
  182.     % If so, implement copy-on-write.
  183.    dup wcheck not { dup length array copy } if
  184.    4 index length 1 eq
  185.     { 2 { 5 -1 roll 0 get } repeat 1 exch
  186.        {    % Stack: value proc map code
  187.      2 copy 5 index put pop
  188.      3 -1 roll 2 index exec 3 1 roll
  189.        } for
  190.     }
  191.     { 4 index 0 get 1 5 index 0 get
  192.       8 -2 roll
  193.       2 { 1 1 index length 1 sub getinterval 8 1 roll } repeat
  194.         % Stack: lo hi next proc map lo0 1 hi0
  195.        { 6 copy get .addmaprange
  196.         % Stack: lo hi oldnext proc map i next submap
  197.      exch 6 1 roll 5 -1 roll pop
  198.         % Stack: lo hi next proc map i submap
  199.      3 copy put pop pop
  200.        }
  201.       for 5 -2 roll pop pop
  202.     }
  203.    ifelse exch pop
  204.  } bind def
  205.  
  206. % ------ notdef operators ------ %
  207.  
  208. /beginnotdefchar    % <count> beginnotdefchar -
  209.  { pop mark
  210.  } bind def
  211. /endnotdefchar        % <code> <cid> ... endnotdefchar -
  212.  { counttomark 2 idiv { 1 index exch .addnotdefrange } repeat pop
  213.  } bind def
  214.  
  215. /beginnotdefrange    % <count> beginnotdefrange -
  216.  { pop mark
  217.  } bind def
  218. /endnotdefrange        % <code_lo> <code_hi> <cid> ... endnotdefrange -
  219.  { counttomark 3 idiv { .addnotdefrange } repeat pop
  220.  } bind def
  221.  
  222. /.addnotdefrange    % <code_lo> <code_hi> <cid_base> .addnotdefrange -
  223.  { { } 1 .getmap .addmaprange 1 .putmap pop
  224.  } bind def
  225.  
  226. % ---------------- Resource category definition ---------------- %
  227.  
  228. currentdict end
  229.  
  230. languagelevel exch 2 .setlanguagelevel
  231.  
  232. /CMap /Generic /Category findresource dup length dict .copydict
  233. /Category defineresource pop
  234.     % We might have loaded CID font support already.
  235. /CIDInit /ProcSet 2 copy { findresource } .internalstopped
  236.     % An interior `stopped' might have reset VM allocation to local.
  237. true .setglobal
  238.  { pop pop 3 -1 roll }
  239.  { dup length 4 index length add dict .copydict 4 -1 roll exch .copydict }
  240. ifelse exch defineresource pop
  241.  
  242. .setlanguagelevel
  243.